package activities;

import java.io.IOException;
import java.net.SocketTimeoutException;

import persistencia.BaseDatos;
import webService.AccesoWebService;
import android.annotation.SuppressLint;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.TaskStackBuilder;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import com.androidmodule.onthego.R;
import entidades.PromocionHot;
import entidades.Reserva;
import excepciones.PromocionEliminadaExcepcion;
import extras.Fonts;
import extras.NetInfo;
import extras.Utilities;
import extras.leerPreferencias;

@SuppressLint("ValidFragment")
public class ActivityPromocionHot extends FragmentActivity{
	///////////DECLARACION DE ATRIBUTOS///////////////
    final static int NOTIFIACION_RESERVA=300;
    private int flagOnPause; 
	private TextView textoTitulo,textoDescripcion,textoDescuento,textoComercio,textoStock,textoCronometro, textoCategoria, textoTipoDePago;
	private Button botonReservar;
	private ImageView imagen_PromoHot;
	private int idPromocion;
	private hiloPromocionHot hiloPromocion;
	private ProgressBar progresoPromocionHot;
	protected TextView textoListaVacia;
	private long tiempoRestante;
	private BaseDatos baseDatos;
	String horaServidor;
	CountDownTimer cuentaRegresiva;
	PromocionHot promoSeleccionada;
	//////////////METODOS DE CICLO DE VIDA DE LA ACTIVIDAD//////////////////////
	
	public void onResume() {
		super.onResume();
		if(flagOnPause==1){
		 this.reanudarCronometroServidor(getApplicationContext());
		 flagOnPause=0;
		}
	}
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.layout_promocion_hot);
		baseDatos = new BaseDatos(getApplicationContext());
		flagOnPause=0;
		promoSeleccionada=new PromocionHot();
		horaServidor = "";
		cuentaRegresiva= temporizador(0);
		hiloPromocion = new hiloPromocionHot();
		idPromocion = getIntent().getExtras().getInt("PromocionId");
		TextView txtTiempoRestante = (TextView) findViewById(R.id.etiqueta_promHotTiempoRestante);
		txtTiempoRestante.setTypeface(Fonts.impact(getApplicationContext()));
		progresoPromocionHot = (ProgressBar) this.findViewById(R.id.progressBarPromocionHot);
		textoListaVacia = (TextView) this.findViewById(android.R.id.empty);
		textoTitulo = (TextView) findViewById(R.id.etiqueta_tituloPromocionHot);
		textoTitulo.setTypeface(Fonts.mvboli(getApplicationContext()));
		textoDescripcion = (TextView) findViewById(R.id.etiqueta_descripcionPromocionHot);
		textoDescripcion.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		textoDescuento = (TextView) findViewById(R.id.etiqueta_descuentoPromocionHot);
		textoDescuento.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		textoComercio = (TextView) findViewById(R.id.etiqueta_comercioPromocionHot);
		textoComercio.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		textoCronometro = (TextView) findViewById(R.id.etiqueta_cronometroPromocionHot);
		textoCronometro.setTypeface(Fonts.impact(getApplicationContext()));
		textoStock = (TextView) findViewById(R.id.etiqueta_stockPromocionHot);
		textoStock.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		textoTipoDePago = (TextView) findViewById(R.id.etiqueta_tipoPagoPromocionHot);
		textoTipoDePago.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		textoCategoria = (TextView) findViewById(R.id.etiqueta_categoriaPromocionHot);
		textoCategoria.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		imagen_PromoHot = (ImageView) findViewById(R.id.imagen_promocionHotParticular);
	    TextView txtAccedeDescuento = (TextView) findViewById(R.id.etiqueta_comercioPromocionHot);
	    txtAccedeDescuento.setTypeface(Fonts.arialNarrow(getApplicationContext()));
		botonReservar = (Button) this.findViewById(R.id.btn_reservar);
		botonReservar.setTypeface(Fonts.impact(getApplicationContext()));
		botonReservar.setOnClickListener(new OnClickListener (){
			@Override
			public void onClick(View arg0) {
		      if(NetInfo.isOnline(getApplicationContext())){
		    	  if(leerPreferencias.readConexionValida(getApplicationContext())){
		    	      DialogFragment dialogoReserva = new ConfirmarReservaDialog();
		    	      dialogoReserva.show(getSupportFragmentManager(), "confirmarReserva");
		    	  }
		    	  else{
		    		  Toast.makeText(getApplicationContext(), getString(R.string.etiqueta_red_invalida),
		    				  Toast.LENGTH_LONG).show();
		    	  }
		      }
		      else{
		    	  Intent sinConexion = new Intent(ActivityPromocionHot.this,ActivityNoConexion.class);
				  startActivity(sinConexion);
		      }
			}
        });
		// hacemso que el hilo lo habilite para asegurarnos que no presione antes de que se cargue
		botonReservar.setEnabled(false);
		if(savedInstanceState==null){
			if(leerPreferencias.readConexionValida(getApplicationContext())){
            buscarPromocion();
			}
            else{
            	Intent direccionarAMain = new Intent(getApplicationContext(),MainActivity.class);   
            	startActivity(direccionarAMain);
            }
		}
		else{
			this.cargarPromocionHot((PromocionHot)savedInstanceState.get("promocion"));
			 botonReservar.setEnabled(true);
			 cuentaRegresiva = temporizador(savedInstanceState.getLong("tiempoRestante")).start();
		}		
	}
	
	@Override
	public void onSaveInstanceState(Bundle savedInstanceState) {
		super.onSaveInstanceState(savedInstanceState);
	    savedInstanceState.putParcelable("promocion", promoSeleccionada);   
	    savedInstanceState.putLong("tiempoRestante", tiempoRestante);
	    cuentaRegresiva.cancel();
	}
	
	public void onPause(){
		super.onPause();
		cuentaRegresiva.cancel();
		flagOnPause = 1;
	}
	//////////////////////////////////////////////////////////////////////////////////
	/**
	 * Recibe como parametro  la promocion Comun obtenida del servidor
	 * y lo carga en el layout
	 * @param promocionWebService
	 * no tiene retorno
	 */
	public void cargarPromocionHot(PromocionHot promocionWebService) {
		promoSeleccionada = promocionWebService;
		textoTitulo.setText(promoSeleccionada.getTitulo());
		textoDescripcion.setText(promoSeleccionada.getDescripcion());
		textoDescuento.setText(String.valueOf(promoSeleccionada.getDescuentoInicial())
				+getString(R.string.etiqueta_porcentaje));
		textoComercio.setText(promoSeleccionada.getComercio());
		textoCronometro.setText(promoSeleccionada.convertirTiempoAString());
		textoStock.setText(getString(R.string.etiqueta_stock) + promoSeleccionada.getStock());
		textoTipoDePago.setText(getString(R.string.etiqueta_tipoPago) +" "+ promoSeleccionada.getTipoPago());
		textoCategoria.setText(promoSeleccionada.getCategoria());
		if (promoSeleccionada.getImagen() != null) {
			imagen_PromoHot.setImageBitmap(promoSeleccionada.getImagen());
		}	
		imagen_PromoHot.setVisibility(ImageView.VISIBLE);
		botonReservar.setVisibility(Button.VISIBLE);
		this.textoListaVacia.setText("");
	}

	/**
	 * Metodo que encapsula la funcionalidad asociada con la busqueda de promociones
	 */
	public void buscarPromocion(){
		if(NetInfo.isOnline(getApplicationContext())){	
			progresoPromocionHot.setVisibility(ProgressBar.VISIBLE);
			textoListaVacia.setText(R.string.etiqueta_carga_promocion);	
		    hiloPromocion.execute();		   
		}
		else{
			Intent sinConexion = new Intent(this,ActivityNoConexion.class);
			startActivity(sinConexion);	
		}
	}
	
	///////////////////////////////////////////HILOS//////////////////////////////////////////////////////
	/**
	 * Clase interna, es el hilo que busca las promocion comun seleccionada en el servidor
	 * 
	 */
	public class hiloPromocionHot extends AsyncTask<Void, Integer, PromocionHot> {
        int codigoError = AccesoWebService.NO_ERROR;
        PromocionHot promocionWebService;
        
        public hiloPromocionHot(){
            promocionWebService = new PromocionHot();
        }

        @Override
        protected PromocionHot doInBackground(Void... params) { 
            try{
    	        AccesoWebService accesoWeb = new AccesoWebService();
    	        promocionWebService = accesoWeb.getPromocionHot(idPromocion);
    	        promoSeleccionada = promocionWebService;
    	        promocionWebService.setTiempoRestante(accesoWeb.getHoraServidor());
    	        tiempoRestante=promocionWebService.getTiempoRestante();   	        
    	    }
            catch(PromocionEliminadaExcepcion promElimi){
            	codigoError = AccesoWebService.PROMOCION_ELIMINADA;
            }
            catch (java.net.SocketTimeoutException timeOut){
           	    codigoError = AccesoWebService.TIMEOUT_ERROR;
           	    Log.e("ERROR TRAYENDO PROMOCION HOT HILO",timeOut.getMessage());
            }
            catch (IOException ex) {
                
                textoCronometro.setText(getApplicationContext().getString
               		 (R.string.etiqueta_problemas_conexion));
            }
            return promocionWebService;
        }
        protected void onProgressUpdate(Integer... values){}
               
        protected void onPostExecute(PromocionHot parametroPromocion){
           if(codigoError==AccesoWebService.TIMEOUT_ERROR){
       	       textoListaVacia.setText(getString(R.string.mensaje_sinAccesoServidor));
           }
           else if (codigoError==AccesoWebService.PROMOCION_ELIMINADA){
        	   Toast.makeText(getApplicationContext(), 
				         getApplicationContext().getString(R.string.excepcion_promocion_eliminada),
				         Toast.LENGTH_LONG).show();
				finish();
           }
           else{
        	   cargarPromocionHot(parametroPromocion); 
        	   botonReservar.setEnabled(true);
        	   /*
        	    * Va aca porque recien cuando se ejecute el hilo, se tiene los 
        	    * datos de la promo y el tiempo, recordar que no es secuencial, la activity lanza
        	    * el hilo y ejectua las demas tareas sin esperar a que termine
        	    */
        	   cuentaRegresiva = temporizador(parametroPromocion.getTiempoRestante()).start();
        	   }
       		progresoPromocionHot.setVisibility(ProgressBar.GONE);
           } 
	}
	
	/**
	 * Clase interna, es el hilo que reserva la promocion
	 * 
	 */
	public class hiloReserva extends AsyncTask<Void, Integer, String> {
        String mensajeError ="";
        String resultadoReservaHilo="";
        int promocionId;
        Context contexto;
        
        public hiloReserva(Context parametroContexto){
        	String hola = "";
            promocionId = Integer.parseInt(promoSeleccionada.getId());
            contexto = parametroContexto;
        }

        @Override
        protected String doInBackground(Void... params) { 
            try{
    	        AccesoWebService accesoWeb = new AccesoWebService();
    	        NetInfo infoMovil = new NetInfo(contexto);
    	        resultadoReservaHilo = accesoWeb.reservarPromocion(promocionId, NetInfo.getTelephoneNumber(contexto), 
    	        		Utilities.getEmail(getApplicationContext()), infoMovil.getMac(),leerPreferencias.readCodigoGCM(getApplicationContext()));
            }
            catch (java.net.SocketTimeoutException timeOut){
           	    mensajeError = "TimeOut";
           	    Log.e("ERROR RESERVANDO PROMOCION HOT HILO TIME OUT",timeOut.getMessage());
            }
            return resultadoReservaHilo;
        }
        protected void onProgressUpdate(Integer... values){}

        protected void onPostExecute(String parametroResultado){
           if(!"".equals(mensajeError)){
   	       Toast.makeText(getApplicationContext(), "No se puede conectar al servidor", Toast.LENGTH_LONG).show();
           }    
           else{
        	   if(parametroResultado.equalsIgnoreCase("SINSTOCK")){
        		   DialogFragment dialogoSinStock = new PromocionSinStockDialog();
 		    	   dialogoSinStock.show(getSupportFragmentManager(), "promocionSinStock");
        	   }
        	   else if(parametroResultado.equalsIgnoreCase("ELIMINADA")){
        		   DialogFragment dialogoSinStock = new PromocionEliminadaDialog();
 		    	   dialogoSinStock.show(getSupportFragmentManager(), "promocionEliminada");
        	   }
        	   else{
        		   //notificarPervaExitosa(contexto,parametroResultado);
        		   mostrarReserva(parametroResultado);
        	   }
    	   }
        } 
	}
	////////////////////////////////////////METODOS PARA EL CRONOMETRO////////////////////
	 /**
     * Este metodo devuele un vector de enteros con las horas, minutos
     * y segundos restantes. El metodo se basa en el principio de que las promociones
     * duran menos de un dia sino falla
     * @return
     */
    public int[] tiempoCronometro(long tiempoRestante){
    	int[] tiempo = new int [3];
    	long diffHoras = tiempoRestante / (60 * 60 * 1000);
    	tiempoRestante=tiempoRestante-(diffHoras*(60 * 60 * 1000));
    	long diffMinutes = tiempoRestante / (60 * 1000);
        tiempoRestante=tiempoRestante-(diffMinutes*(60 * 1000));
        long diffSeconds = tiempoRestante/ 1000;
        
        tiempo[0]=(int) diffHoras;
        tiempo[1]=(int) diffMinutes;
        tiempo[2]=(int) diffSeconds;
        
        return tiempo;
    }
    
    /**
     * Este metodo toma el vector de horas minutos y segundos
     * y lo transforma a string par amostrar el cronometro
     * @return
     */
    public String convertirTiempoAString(long tiempoRestante){
    	int[] tiempo = tiempoCronometro(tiempoRestante);
    	return ""+tiempo[0]+":"+tiempo[1]+":"+tiempo[2];
    }
	
    /**
     * Devuelve un temporizador encargado de refrescar el textview simulando  un cronometro
     * invertido
     * @param tiempoRestante
     * @return
     */
	public CountDownTimer temporizador (long parametroTiempoRestante){
		return new CountDownTimer(parametroTiempoRestante, 1000) {

		     public void onTick(long millisUntilFinished) {
		         textoCronometro.setText(convertirTiempoAString(millisUntilFinished));
		         tiempoRestante = millisUntilFinished;
		     }

		     public void onFinish() {
		         textoCronometro.setText(getString(R.string.etiqueta_duracionTerminada));
		     }
		  };
	}
	
	/**
	 * Devuelve un temporizaodr que se encargara de desactivar
	 * la notificacion de la reserva una vez haya pasado el tiempo de toleranca
	 * @param tiempoRestante
	 * @return
	 */
	public CountDownTimer temporizadorCancelarNotificacion (long parametroTiempoRestante, final String idPromocion){
		return new CountDownTimer(parametroTiempoRestante, 1000) {
             
		     public void onTick(long millisUntilFinished) {
		    	baseDatos.actualizarTiempoRestante(idPromocion, millisUntilFinished);
		     }

		     public void onFinish() {
		    	 String notificationService = Context.NOTIFICATION_SERVICE;
			 	 NotificationManager notificationManager =(NotificationManager) getApplicationContext().getSystemService(notificationService);
			 	 notificationManager.cancel(ActivityPromocionHot.NOTIFIACION_RESERVA);
		     }
		  };
	}
	
	/**
	 * Devuelve un temporizaodr que se encargara de eliminar la reserva de la bd
	 * @param tiempoRestante
	 * @return
	 */
	public CountDownTimer temporizadorEliminarReserva(long parametroTiempoRestante, final String codigoReserva){
		return new CountDownTimer(parametroTiempoRestante, 1000) {
             String codigo = codigoReserva;
		     public void onTick(long millisUntilFinished) {
		    	
		     }

		     public void onFinish() {
		    	baseDatos.eliminarReserva(codigo);
		     }
		  };
	}
	/////////////////////////////////HILO PARA RESERVAR//////////////////////////////////////////////
	
	////////////////////////METODO PARA LA NOTIFICACION/////////////////////
	/** este metodo lanza la notificacion indicando que la reserva fue exitosa, adicionalmente inicia un temporizador
	 * con el tiempo de tolerancia de la reserva, le cual se encarga de cancelar
	 * @param parametroContexto
	 * @param codigoReserva
	 */
	public void notificarPervaExitosa(Context parametroContexto, String codigoReserva){
		long tolerancia = promoSeleccionada.getTolerancia()*60*1000;
		String idParaBas=promoSeleccionada.getId();
		String comercioPromocion = promoSeleccionada.getComercio();
		String tituloPromocion = promoSeleccionada.getTitulo();
		int aumento = promoSeleccionada.getDescuentoFinal() - promoSeleccionada.getDescuentoInicial();
		Reserva nuevaReserva= new Reserva(); 
		nuevaReserva.setComercio(comercioPromocion);
		nuevaReserva.setDescuento(promoSeleccionada.getDescuentoInicial());
		nuevaReserva.setCodigo(codigoReserva);
		nuevaReserva.setDifDescuentos(aumento);
		nuevaReserva.setTituloProm(promoSeleccionada.getTitulo());
		nuevaReserva.setImagen(promoSeleccionada.getImagenByte());
		nuevaReserva.setHora(Utilities.obtenerHoraActual());
		baseDatos.insertarReserva(nuevaReserva);
		final Uri defaultNotificationSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
			NotificationCompat.Builder notBuilder =
		        new NotificationCompat.Builder(parametroContexto)
		        .setSmallIcon( R.drawable.hot_prom_notification)
		        .setContentTitle(getString(R.string.notificacion_reserva_titulo)+" "+comercioPromocion)
		        .setContentInfo(getString(R.string.notificacion_reserva_ticker))
		        .setSound(defaultNotificationSound)
		        .setContentText(tituloPromocion +" "+parametroContexto.getString(R.string.notificacion_reserva_mensaje)+ 
		        		" "+codigoReserva);
		Intent resultIntent = new Intent(parametroContexto, ActivityReservaParticular.class);
		resultIntent.putExtra("codigoReserva", codigoReserva);
	    resultIntent.putExtra("tolerancia", tolerancia);
	    resultIntent.putExtra("idPromocion", idParaBas);
		TaskStackBuilder stackBuilder = TaskStackBuilder.create(parametroContexto);
		stackBuilder.addParentStack(MainActivity.class);
		// Adds the back stack for the Intent (but not the Intent itself)
		// Adds the Intent that starts the Activity to the top of the stack
		stackBuilder.addNextIntentWithParentStack(resultIntent);
		PendingIntent resultPendingIntent =
		        stackBuilder.getPendingIntent(
		            0,
		            PendingIntent.FLAG_UPDATE_CURRENT
		        );
		notBuilder.setContentIntent(resultPendingIntent);
		baseDatos.insertarTiempoPorPromocion(idParaBas, tolerancia);
		temporizadorEliminarReserva(tolerancia,idParaBas).start();
		NotificationManager mNotificationManager =
			    (NotificationManager) parametroContexto.getSystemService(Context.NOTIFICATION_SERVICE);
			// mId allows you to update the notification later on.
			mNotificationManager.notify(NOTIFIACION_RESERVA, notBuilder.build());
		
	}
	
	public void mostrarReserva(String codigoReserva){
		Reserva nuevaReserva= new Reserva(); 
		nuevaReserva.setHoraFin(Utilities.sumarMinutosAFecha(promoSeleccionada.getTolerancia()));
		nuevaReserva.setHora(Utilities.obtenerHoraActual());
		nuevaReserva.setComercio(promoSeleccionada.getComercio());
		nuevaReserva.setTituloProm(promoSeleccionada.getTitulo());
		nuevaReserva.setDifDescuentos(promoSeleccionada.getDescuentoFinal() - promoSeleccionada.getDescuentoInicial());
		nuevaReserva.setImagen(promoSeleccionada.getImagenByte());
		nuevaReserva.setCodigo(codigoReserva);
		nuevaReserva.setDescuento(promoSeleccionada.getDescuentoInicial());
		baseDatos.insertarReserva(nuevaReserva);
		temporizadorEliminarReserva(promoSeleccionada.getTolerancia()*60*1000,codigoReserva).start();
		Intent abrirReservas = new Intent(getApplicationContext(),ActivityReservas.class);
		abrirReservas.putExtra("reservaEfectuada", codigoReserva);
		startActivity(abrirReservas);
		
		
		
	}
	
	///////////////////////////////////////////////////////////SECCION DIALOGOS/////////////////////////////////////
	
	public class ConfirmarReservaDialog extends DialogFragment{
		
		public Dialog onCreateDialog(Bundle savedInstanceState) {
			AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
			builder.setMessage(getString(R.string.dialogo_confirmar_reserva_mensaje));
			builder.setTitle(getString(R.string.dialogo_confirmar_reserva_titulo));
			builder.setPositiveButton(getString(R.string.dialogo_boton_aceptar), new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                	String hola = "";
    				hiloReserva ejecutarReserva = new hiloReserva(getApplicationContext());
    				ejecutarReserva.execute();
                }
            });
			builder.setNegativeButton(getString(R.string.dialogo_boton_cancelar), new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {}
            });			
			return builder.create();
		}
	}
    public class PromocionSinStockDialog extends DialogFragment{
		
		public Dialog onCreateDialog(Bundle savedInstanceState) {
			AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
			builder.setMessage(getString(R.string.dialogo_promocion_sin_stock_mensaje));
			builder.setTitle(getString(R.string.dialogo_promocion_sin_stock_titulo));
			builder.setPositiveButton(getString(R.string.dialogo_boton_aceptar), new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {}
            });
			return builder.create();
		}
	}

	public class PromocionEliminadaDialog extends DialogFragment {

		public Dialog onCreateDialog(Bundle savedInstanceState) {
			AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
			builder.setMessage(getString(R.string.excepcion_promocion_eliminada));
			builder.setTitle(getString(R.string.dialogo_promocion_sin_stock_titulo));
			builder.setPositiveButton(
					getString(R.string.dialogo_boton_aceptar),
					new DialogInterface.OnClickListener() {
						public void onClick(DialogInterface dialog, int id) {
							Intent intent = new Intent(getApplicationContext(),ActivityPromocionesHot.class);
							startActivity(intent);
						}
					});
			return builder.create();
		}
	}
    
    /**
     * Metodo que restablece el cronometro frente a cambis dle cronometro
     */
    public void reanudarCronometroServidor(final Context contexto){
    	new AsyncTask<Void, Integer, String>() {
            int codigoError= AccesoWebService.NO_ERROR;

                @Override
                protected String doInBackground(Void... params) { 
                	 String msg = "";
                	 String fechaHora="";
                	 AccesoWebService webService = new AccesoWebService();
                	 msg= "Tiempo conseguido con extio";
                     try {
                         fechaHora=webService.getHoraServidor();
                         promoSeleccionada.setTiempoRestante(fechaHora);
                     }
                     catch(SocketTimeoutException time){
                    	 codigoError=AccesoWebService.TIMEOUT_ERROR;
                     }
                     catch (IOException ex) {
                        ex.printStackTrace();
                     
                     }
                     return msg;
                }

                protected void onProgressUpdate(Integer... values){}

                protected void onPostExecute(String mensaje){
                	if(codigoError==AccesoWebService.NO_ERROR){
                		cuentaRegresiva = temporizador(promoSeleccionada.getTiempoRestante()).start();
                		
                	}
                	else{
                	    textoCronometro.setText(contexto.getString
                       		 (R.string.etiqueta_problemas_conexion));
                	}
                	
                }
        }.execute();
    }
    
}
